package com.mxw;

import com.lmax.disruptor.BlockingWaitStrategy;
import com.lmax.disruptor.dsl.ProducerType;
import com.mxw.disruptor.MessageConsumer;
import com.mxw.disruptor.RingBufferWorkerPoolFactory;
import com.mxw.server.MessageConsumerImpl4Server;
import com.mxw.server.NettyServer;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;


@SpringBootApplication
public class ServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServerApplication.class, args);

        //消费者数量
        MessageConsumer[] conusmers = new MessageConsumer[4];

        //创建消费者
        for(int i =0; i < conusmers.length; i++) {
            MessageConsumer messageConsumer = new
                    MessageConsumerImpl4Server("code:serverId:" + i);
            conusmers[i] = messageConsumer;
        }

        // disruptor工厂初始化
        RingBufferWorkerPoolFactory.getInstance().initAndStart(
                //ProducerType:单生产者或多生产者
                ProducerType.MULTI,
                1024*1024,
                /**
                  WaitStrategy等待策略
                  决定一个Consumer将如何等待Producer将Event置入RingBuffer
                  主要策略有：
                  BlockingWaitStrategy：阻塞等待策略，最低效的策略，但其对CPU的消耗最小并且在各种不同
                  部署环境中能提供更加一致的性能表现。
                  SleepingWaitStrategy：休眠等待策略，性能表现跟BlockingWaitStrategy差不多，对CPU的消
                  耗也类似，但其对生产者线程的影响最小，适合用于异步日志类似的场景。
                  YieldingWaitStrategy：产生等待策略，性能最好，适合用于低延迟的系统，在要求极高性能且
                  事件处理线程数小于CPU逻辑核心数的场景中，推荐使用。是无锁并行
                 */
                new BlockingWaitStrategy(),
                conusmers);


        new NettyServer();
    }
}